TypeScriptマスターデータ管理：参照データ型を実装するためのガイド

            
function processOrder(orderId: number, newStatus: string) {
  if (newStatus === 'shipped') {
    // Logic for shipping
    console.log(`Order ${orderId} has been shipped.`);
  } else if (newStatus === 'delivered') {
    // Logic for delivery confirmation
    console.log(`Order ${orderId} confirmed as delivered.`);
  } else if (newStatus === 'pending') {
    // ...and so on
  }
}

// Somewhere else in the application...
processOrder(12345, 'Shipped'); // Uh oh, a typo!

            

              
                Copy
              
            
          

            
export enum OrderStatus {
  Pending = 'PENDING',
  Processing = 'PROCESSING',
  Shipped = 'SHIPPED',
  Delivered = 'DELIVERED',
  Cancelled = 'CANCELLED',
}

function processOrder(orderId: number, newStatus: OrderStatus) {
  if (newStatus === OrderStatus.Shipped) {
    console.log(`Order ${orderId} has been shipped.`);
  }
}

processOrder(123, OrderStatus.Shipped); // Correct and type-safe
// processOrder(123, 'SHIPPED'); // Compile-time error! Great!

            

              
                Copy
              
            
          

            
export type OrderStatus =
  | 'PENDING'
  | 'PROCESSING'
  | 'SHIPPED'
  | 'DELIVERED'
  | 'CANCELLED';

function processOrder(orderId: number, newStatus: OrderStatus) {
  if (newStatus === 'SHIPPED') {
    console.log(`Order ${orderId} has been shipped.`);
  }
}

processOrder(123, 'SHIPPED'); // Correct and type-safe
// processOrder(123, 'shipped'); // Compile-time error! Awesome!

            

              
                Copy
              
            
          

            
// Duplication of values
export type OrderStatus = 'PENDING' | 'PROCESSING' | 'SHIPPED';

export const ALL_ORDER_STATUSES = ['PENDING', 'PROCESSING', 'SHIPPED'];

            

              
                Copy
              
            
          

            
// 1. Define the runtime data with 'as const'
export const ORDER_STATUSES = [
  'PENDING',
  'PROCESSING',
  'SHIPPED',
  'DELIVERED',
  'CANCELLED',
] as const;

// 2. Derive the type from the runtime data
export type OrderStatus = typeof ORDER_STATUSES[number];
//   ^? type OrderStatus = "PENDING" | "PROCESSING" | "SHIPPED" | "DELIVERED" | "CANCELLED"

// 3. Use it in your functions
function processOrder(orderId: number, newStatus: OrderStatus) {
  if (newStatus === 'SHIPPED') {
    console.log(`Order ${orderId} has been shipped.`);
  }
}

// 4. Use it at runtime AND compile time
processOrder(123, 'SHIPPED'); // Type-safe!

// And you can easily iterate over it for UIs!
function getStatusOptions() {
  return ORDER_STATUSES.map(status => ({ value: status, label: status.toLowerCase() }));
}

            

              
                Copy
              
            
          

            
export const COUNTRIES = [
  {
    code: 'US',
    name: 'United States of America',
    dial: '+1',
    continent: 'North America',
  },
  {
    code: 'DE',
    name: 'Germany',
    dial: '+49',
    continent: 'Europe',
  },
  {
    code: 'IN',
    name: 'India',
    dial: '+91',
    continent: 'Asia',
  },
  {
    code: 'BR',
    name: 'Brazil',
    dial: '+55',
    continent: 'South America',
  },
] as const;

            

              
                Copy
              
            
          

            
// Derive the type for a single country object
export type Country = typeof COUNTRIES[number];
/*
  ^? type Country = {
      readonly code: "US";
      readonly name: "United States of America";
      readonly dial: "+1";
      readonly continent: "North America";
  } | {
      readonly code: "DE";
      ...
  }
*/

// Derive a union type of all valid country codes
export type CountryCode = Country['code']; // or `typeof COUNTRIES[number]['code']`
//   ^? type CountryCode = "US" | "DE" | "IN" | "BR"

// Derive a union type of all continents
export type Continent = Country['continent'];
//   ^? type Continent = "North America" | "Europe" | "Asia" | "South America"

            

              
                Copy
              
            
          

            
// file: src/services/referenceData.ts

// ... (our COUNTRIES constant and derived types from above)

export const getCountries = () => COUNTRIES;

export const getCountryByCode = (code: CountryCode): Country | undefined => {
  // The 'find' method is perfectly type-safe here
  return COUNTRIES.find(country => country.code === code);
};

export const getCountriesByContinent = (continent: Continent): Country[] => {
  return COUNTRIES.filter(country => country.continent === continent);
};

// You can also export the raw data and types if needed
export { COUNTRIES, Country, CountryCode, Continent };

            

              
                Copy
              
            
          

            
import { z } from 'zod';

// 1. Define the schema for a single country using Zod
const CountrySchema = z.object({
  code: z.string().length(2),
  name: z.string(),
  dial: z.string(),
  continent: z.string(),
});

// 2. Define the schema for the API response (an array of countries)
const CountriesApiResponseSchema = z.array(CountrySchema);

// 3. Infer the TypeScript type from the Zod schema
export type Country = z.infer;

// We can still get a code type, but it will be 'string' since we don't know the values ahead of time.
// If the list is small and fixed, you can use z.enum(['US', 'DE', ...]) for more specific types.
export type CountryCode = Country['code'];

// 4. A service to fetch and cache the data
class ReferenceDataService {
  private countries: Country[] | null = null;

  async fetchAndCacheCountries(): Promise {
    if (this.countries) {
      return this.countries;
    }

    const response = await fetch('/api/v1/countries');
    const jsonData = await response.json();

    // Runtime validation!
    const validationResult = CountriesApiResponseSchema.safeParse(jsonData);

    if (!validationResult.success) {
      console.error('Invalid country data from API:', validationResult.error);
      throw new Error('Failed to load reference data.');
    }

    this.countries = validationResult.data;
    return this.countries;
  }
}

export const referenceDataService = new ReferenceDataService();

            

              
                Copy
              
            
          

            
import React from 'react';
import { COUNTRIES, CountryCode } from '../services/referenceData';

interface CountrySelectorProps {
  selectedValue: CountryCode | null;
  onChange: (newCode: CountryCode) => void;
}

export const CountrySelector: React.FC = ({ selectedValue, onChange }) => {
  return (
     onChange(e.target.value as CountryCode)}
    >
      Select a country
      {COUNTRIES.map((country) => (
        
          {country.name} ({country.code})
        
      ))}
    
  );
};

            

              
                Copy
              
            
          

            
import { OrderStatus } from '../services/referenceData';

interface Order {
  id: string;
  status: OrderStatus;
  items: any[];
}

// This function can only be called with a valid status.
function canCancelOrder(order: Order): boolean {
  // No need to check for typos like 'pendng' or 'Procesing'
  return order.status === 'PENDING' || order.status === 'PROCESSING';
}

const myOrder: Order = { id: 'xyz', status: 'SHIPPED', items: [] };

if (canCancelOrder(myOrder)) {
  // This block is correctly (and safely) not executed.
}

            

              
                Copy
              
            
          

            
export const ORDER_STATUSES = [
  { code: 'PENDING', i18nKey: 'orderStatus.pending' },
  { code: 'PROCESSING', i18nKey: 'orderStatus.processing' },
  { code: 'SHIPPED', i18nKey: 'orderStatus.shipped' },
] as const;

export type OrderStatusCode = typeof ORDER_STATUSES[number]['code'];

            

              
                Copy